{
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/AnamikaMangore/AnamikaMangore/blob/main/Arrythmia%20Project.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "hgUiQOXDt3PL"
      },
      "source": [
        "# Introduction"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "uLS0-eQqt3PL"
      },
      "source": [
        "Recently, I was reviewing Andrew Ng's team's work(https://stanfordmlgroup.github.io/projects/ecg/) on heart arrhythmia detector with convolutional neural networks (CNN). I found this quite fascinating especially with emergence of wearable products (e.g. Apple Watch and portable EKG machines) that are capable of monitoring your heart while at home. As such, I was curious how to build a machine learning algorithm that could detect abnormal heart beats. Here we will use an ECG signal (continuous electrical measurement of the heart) and train 3 neural networks to predict heart arrythmias: dense neural network, CNN, and LSTM.  "
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Xhfr8h-Bt3PM"
      },
      "source": [
        "# Dataset"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "B6L__gbMt3PM"
      },
      "source": [
        "We will use the MIH-BIH Arrythmia dataset from https://physionet.org/content/mitdb/1.0.0/. This is a dataset with 48 half-hour two-channel ECG recordings measured at 360 Hz. The recordings have annotations from cardiologists for each heart beat. The symbols for the annotations can be found at https://archive.physionet.org/physiobank/annotations.shtml"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "7XXKONnDt3PM"
      },
      "source": [
        "# Project Definition"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "cSPbJZSPt3PM"
      },
      "source": [
        "Predict if a heart beat from the first ECG signal has an arrhythmia for each 6 second window centered on the peak of the heart beat."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "q4hFh0yQt3PM"
      },
      "source": [
        "To simplify the problem, we will assume that a QRS detector is capable of automatically identifying the peak of each heart beat. We will ignore any non-beat annotations and any heart beats in the first or last 3 seconds of the recording due to reduced data. We will use a window of 6 seconds so we can compare the current beat to beats just before and after. This decision was based after talking to a physician who said it is easier to identify if you have something to compare it to."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "T4F7dOxpt3PM"
      },
      "source": [
        "# Data Preparation"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 73,
      "metadata": {
        "id": "ZPfy4rqOt3PM"
      },
      "outputs": [],
      "source": [
        "import pandas as pd\n",
        "import numpy as np\n",
        "import matplotlib.pyplot as plt\n",
        "from os import listdir\n"
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# prompt: wriet the to access drive\n",
        "\n",
        "from google.colab import drive\n",
        "drive.mount('/content/drive')\n"
      ],
      "metadata": {
        "id": "qGLHDac9ud3P",
        "outputId": "819cf367-bd6d-4572-f647-fd3c9198f534",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "execution_count": 74,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Drive already mounted at /content/drive; to attempt to forcibly remount, call drive.mount(\"/content/drive\", force_remount=True).\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 75,
      "metadata": {
        "id": "9n34qEEIt3PN"
      },
      "outputs": [],
      "source": [
        "# data must be downloaded and path provided\n",
        "data_path = '/content/drive/MyDrive/Arrhythmia-CNN-master/data/mit-bih-arrhythmia-database-1.0.0/100.atr'\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 76,
      "metadata": {
        "id": "26cClQO7t3PN"
      },
      "outputs": [],
      "source": [
        "# list of patients\n",
        "pts = ['100','101','102','103','104','105','106','107',\n",
        "       '108','109','111','112','113','114','115','116',\n",
        "       '117','118','119','121','122','123','124','200',\n",
        "       '201','202','203','205','207','208','209','210',\n",
        "       '212','213','214','215','217','219','220','221',\n",
        "       '222','223','228','230','231','232','233','234']"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Cm7OZuRht3PN"
      },
      "source": [
        "Here we will use a pypi package wfdb for loading the ecg and annotations.  "
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "!pip install wfdb"
      ],
      "metadata": {
        "id": "bfZJHyNCuGYE",
        "outputId": "978747fc-214e-467b-9a1f-e261b581e984",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "execution_count": 77,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Requirement already satisfied: wfdb in /usr/local/lib/python3.11/dist-packages (4.2.0)\n",
            "Requirement already satisfied: matplotlib>=3.2.2 in /usr/local/lib/python3.11/dist-packages (from wfdb) (3.10.0)\n",
            "Requirement already satisfied: numpy>=1.26.4 in /usr/local/lib/python3.11/dist-packages (from wfdb) (1.26.4)\n",
            "Requirement already satisfied: pandas>=2.2.3 in /usr/local/lib/python3.11/dist-packages (from wfdb) (2.2.3)\n",
            "Requirement already satisfied: requests>=2.8.1 in /usr/local/lib/python3.11/dist-packages (from wfdb) (2.32.3)\n",
            "Requirement already satisfied: scipy>=1.13.0 in /usr/local/lib/python3.11/dist-packages (from wfdb) (1.13.1)\n",
            "Requirement already satisfied: soundfile>=0.10.0 in /usr/local/lib/python3.11/dist-packages (from wfdb) (0.13.1)\n",
            "Requirement already satisfied: contourpy>=1.0.1 in /usr/local/lib/python3.11/dist-packages (from matplotlib>=3.2.2->wfdb) (1.3.1)\n",
            "Requirement already satisfied: cycler>=0.10 in /usr/local/lib/python3.11/dist-packages (from matplotlib>=3.2.2->wfdb) (0.12.1)\n",
            "Requirement already satisfied: fonttools>=4.22.0 in /usr/local/lib/python3.11/dist-packages (from matplotlib>=3.2.2->wfdb) (4.56.0)\n",
            "Requirement already satisfied: kiwisolver>=1.3.1 in /usr/local/lib/python3.11/dist-packages (from matplotlib>=3.2.2->wfdb) (1.4.8)\n",
            "Requirement already satisfied: packaging>=20.0 in /usr/local/lib/python3.11/dist-packages (from matplotlib>=3.2.2->wfdb) (24.2)\n",
            "Requirement already satisfied: pillow>=8 in /usr/local/lib/python3.11/dist-packages (from matplotlib>=3.2.2->wfdb) (11.1.0)\n",
            "Requirement already satisfied: pyparsing>=2.3.1 in /usr/local/lib/python3.11/dist-packages (from matplotlib>=3.2.2->wfdb) (3.2.1)\n",
            "Requirement already satisfied: python-dateutil>=2.7 in /usr/local/lib/python3.11/dist-packages (from matplotlib>=3.2.2->wfdb) (2.8.2)\n",
            "Requirement already satisfied: pytz>=2020.1 in /usr/local/lib/python3.11/dist-packages (from pandas>=2.2.3->wfdb) (2025.1)\n",
            "Requirement already satisfied: tzdata>=2022.7 in /usr/local/lib/python3.11/dist-packages (from pandas>=2.2.3->wfdb) (2025.1)\n",
            "Requirement already satisfied: charset-normalizer<4,>=2 in /usr/local/lib/python3.11/dist-packages (from requests>=2.8.1->wfdb) (3.4.1)\n",
            "Requirement already satisfied: idna<4,>=2.5 in /usr/local/lib/python3.11/dist-packages (from requests>=2.8.1->wfdb) (3.10)\n",
            "Requirement already satisfied: urllib3<3,>=1.21.1 in /usr/local/lib/python3.11/dist-packages (from requests>=2.8.1->wfdb) (2.3.0)\n",
            "Requirement already satisfied: certifi>=2017.4.17 in /usr/local/lib/python3.11/dist-packages (from requests>=2.8.1->wfdb) (2025.1.31)\n",
            "Requirement already satisfied: cffi>=1.0 in /usr/local/lib/python3.11/dist-packages (from soundfile>=0.10.0->wfdb) (1.17.1)\n",
            "Requirement already satisfied: pycparser in /usr/local/lib/python3.11/dist-packages (from cffi>=1.0->soundfile>=0.10.0->wfdb) (2.22)\n",
            "Requirement already satisfied: six>=1.5 in /usr/local/lib/python3.11/dist-packages (from python-dateutil>=2.7->matplotlib>=3.2.2->wfdb) (1.17.0)\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 78,
      "metadata": {
        "id": "Ph0XR2WCt3PN"
      },
      "outputs": [],
      "source": [
        "import wfdb"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "HgRegv27t3PN"
      },
      "source": [
        "Let's load all the annotations and see the distribution of heart beat types across all files."
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "data_path = \"/content/drive/MyDrive/Arrhythmia-CNN-master/data/mit-bih-arrhythmia-database-1.0.0/\"\n",
        "file = data_path + \"100\"  # Ensure correct filename without extra extension\n",
        "annotation = wfdb.rdann(file, 'atr')\n"
      ],
      "metadata": {
        "id": "teIWWKm0yvgL"
      },
      "execution_count": 79,
      "outputs": []
    },
    {
      "cell_type": "code",
      "execution_count": 80,
      "metadata": {
        "id": "a_I1WoDrt3PN"
      },
      "outputs": [],
      "source": [
        "df = pd.DataFrame()\n",
        "\n",
        "for pt in pts:\n",
        "    file = data_path + pt\n",
        "    annotation = wfdb.rdann(file, 'atr')\n",
        "    sym = annotation.symbol\n",
        "\n",
        "    values, counts = np.unique(sym, return_counts=True)\n",
        "    df_sub = pd.DataFrame({'sym':values, 'val':counts, 'pt':[pt]*len(counts)})\n",
        "    df = pd.concat([df, df_sub],axis = 0)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 81,
      "metadata": {
        "id": "7QffgmPpt3PN",
        "outputId": "8a2a2a36-e98f-40a0-f33e-0b9a82e89666",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 837
        }
      },
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "sym\n",
              "N    75052\n",
              "L     8075\n",
              "R     7259\n",
              "V     7130\n",
              "/     7028\n",
              "A     2546\n",
              "+     1291\n",
              "f      982\n",
              "F      803\n",
              "~      616\n",
              "!      472\n",
              "\"      437\n",
              "j      229\n",
              "x      193\n",
              "a      150\n",
              "|      132\n",
              "E      106\n",
              "J       83\n",
              "Q       33\n",
              "e       16\n",
              "[        6\n",
              "]        6\n",
              "S        2\n",
              "Name: val, dtype: int64"
            ],
            "text/html": [
              "<div>\n",
              "<style scoped>\n",
              "    .dataframe tbody tr th:only-of-type {\n",
              "        vertical-align: middle;\n",
              "    }\n",
              "\n",
              "    .dataframe tbody tr th {\n",
              "        vertical-align: top;\n",
              "    }\n",
              "\n",
              "    .dataframe thead th {\n",
              "        text-align: right;\n",
              "    }\n",
              "</style>\n",
              "<table border=\"1\" class=\"dataframe\">\n",
              "  <thead>\n",
              "    <tr style=\"text-align: right;\">\n",
              "      <th></th>\n",
              "      <th>val</th>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>sym</th>\n",
              "      <th></th>\n",
              "    </tr>\n",
              "  </thead>\n",
              "  <tbody>\n",
              "    <tr>\n",
              "      <th>N</th>\n",
              "      <td>75052</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>L</th>\n",
              "      <td>8075</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>R</th>\n",
              "      <td>7259</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>V</th>\n",
              "      <td>7130</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>/</th>\n",
              "      <td>7028</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>A</th>\n",
              "      <td>2546</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>+</th>\n",
              "      <td>1291</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>f</th>\n",
              "      <td>982</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>F</th>\n",
              "      <td>803</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>~</th>\n",
              "      <td>616</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>!</th>\n",
              "      <td>472</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>\"</th>\n",
              "      <td>437</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>j</th>\n",
              "      <td>229</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>x</th>\n",
              "      <td>193</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>a</th>\n",
              "      <td>150</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>|</th>\n",
              "      <td>132</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>E</th>\n",
              "      <td>106</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>J</th>\n",
              "      <td>83</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>Q</th>\n",
              "      <td>33</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>e</th>\n",
              "      <td>16</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>[</th>\n",
              "      <td>6</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>]</th>\n",
              "      <td>6</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>S</th>\n",
              "      <td>2</td>\n",
              "    </tr>\n",
              "  </tbody>\n",
              "</table>\n",
              "</div><br><label><b>dtype:</b> int64</label>"
            ]
          },
          "metadata": {},
          "execution_count": 81
        }
      ],
      "source": [
        "df.groupby('sym').val.sum().sort_values(ascending = False)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 82,
      "metadata": {
        "id": "UOTfjXP6t3PO"
      },
      "outputs": [],
      "source": [
        "# list of nonbeat and abnormal\n",
        "nonbeat = ['[','!',']','x','(',')','p','t','u','`',\n",
        "           '\\'','^','|','~','+','s','T','*','D','=','\"','@','Q','?']\n",
        "abnormal = ['L','R','V','/','A','f','F','j','a','E','J','e','S']"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 83,
      "metadata": {
        "id": "4hKMb6KHt3PO"
      },
      "outputs": [],
      "source": [
        "# break into normal, abnormal or nonbeat\n",
        "df['cat'] = -1\n",
        "df.loc[df.sym == 'N','cat'] = 0\n",
        "df.loc[df.sym.isin(abnormal), 'cat'] = 1"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 84,
      "metadata": {
        "id": "d5UHtvQ_t3PO",
        "outputId": "fe31a15b-d64c-43c3-9353-7f4c312caf98",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 210
        }
      },
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "cat\n",
              "-1     3186\n",
              " 0    75052\n",
              " 1    34409\n",
              "Name: val, dtype: int64"
            ],
            "text/html": [
              "<div>\n",
              "<style scoped>\n",
              "    .dataframe tbody tr th:only-of-type {\n",
              "        vertical-align: middle;\n",
              "    }\n",
              "\n",
              "    .dataframe tbody tr th {\n",
              "        vertical-align: top;\n",
              "    }\n",
              "\n",
              "    .dataframe thead th {\n",
              "        text-align: right;\n",
              "    }\n",
              "</style>\n",
              "<table border=\"1\" class=\"dataframe\">\n",
              "  <thead>\n",
              "    <tr style=\"text-align: right;\">\n",
              "      <th></th>\n",
              "      <th>val</th>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>cat</th>\n",
              "      <th></th>\n",
              "    </tr>\n",
              "  </thead>\n",
              "  <tbody>\n",
              "    <tr>\n",
              "      <th>-1</th>\n",
              "      <td>3186</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>0</th>\n",
              "      <td>75052</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>1</th>\n",
              "      <td>34409</td>\n",
              "    </tr>\n",
              "  </tbody>\n",
              "</table>\n",
              "</div><br><label><b>dtype:</b> int64</label>"
            ]
          },
          "metadata": {},
          "execution_count": 84
        }
      ],
      "source": [
        "df.groupby('cat').val.sum()"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "rZbAVvgGt3PO"
      },
      "source": [
        "Let's write a function for loading a single patient's signals and annotations. Note the annotation values are the indices of the signal array."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 85,
      "metadata": {
        "id": "FopDdc2Ct3PO"
      },
      "outputs": [],
      "source": [
        "def load_ecg(file):\n",
        "    # load the ecg\n",
        "    # example file: 'mit-bih-arrhythmia-database-1.0.0/101'\n",
        "\n",
        "    # load the ecg\n",
        "    record = wfdb.rdrecord(file)\n",
        "    # load the annotation\n",
        "    annotation = wfdb.rdann(file, 'atr')\n",
        "\n",
        "    # extract the signal\n",
        "    p_signal = record.p_signal\n",
        "\n",
        "    # verify frequency is 360\n",
        "    assert record.fs == 360, 'sample freq is not 360'\n",
        "\n",
        "    # extract symbols and annotation index\n",
        "    atr_sym = annotation.symbol\n",
        "    atr_sample = annotation.sample\n",
        "\n",
        "    return p_signal, atr_sym, atr_sample"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "NHQBxt61t3PO"
      },
      "source": [
        "Let's check out what abnormal beats are in a patient's ecg:"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 86,
      "metadata": {
        "id": "vPKCQZlKt3PO"
      },
      "outputs": [],
      "source": [
        "file = data_path + pts[0]"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 87,
      "metadata": {
        "id": "-UsaJrAet3PO"
      },
      "outputs": [],
      "source": [
        "p_signal, atr_sym, atr_sample = load_ecg(file)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 88,
      "metadata": {
        "id": "5zQ4XtaUt3PP",
        "outputId": "1d9544be-f6f8-43b4-93aa-459d6eadf9da",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "+ 3\n",
            "J 50\n",
            "N 2700\n",
            "V 3\n",
            "~ 8\n"
          ]
        }
      ],
      "source": [
        "values, counts = np.unique(sym, return_counts=True)\n",
        "for v,c in zip(values, counts):\n",
        "    print(v,c)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "MPxpo5Zet3PP"
      },
      "source": [
        "Let's make a plot of these, zooming in on one of the abnormal beats"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 89,
      "metadata": {
        "id": "nnoTFLOot3PP",
        "outputId": "6922730a-67e4-4f17-ece7-40c26e83ab8f",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "[2044, 66792, 74986, 99579, 128085, 170719, 279576, 305709, 307745, 312825]"
            ]
          },
          "metadata": {},
          "execution_count": 89
        }
      ],
      "source": [
        "# get abnormal beat index\n",
        "ab_index = [b for a,b in zip(atr_sym,atr_sample) if a in abnormal][:10]\n",
        "ab_index"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 90,
      "metadata": {
        "id": "N69aCxByt3PP"
      },
      "outputs": [],
      "source": [
        "x = np.arange(len(p_signal))"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 91,
      "metadata": {
        "id": "jjJzfVkNt3PP",
        "outputId": "7e0cc36e-5424-4dc6-8308-875cc02744f8",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 449
        }
      },
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 640x480 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        }
      ],
      "source": [
        "left = ab_index[1]-1080\n",
        "right = ab_index[1]+1080\n",
        "\n",
        "plt.plot(x[left:right],p_signal[left:right,0],'-',label='ecg',)\n",
        "plt.plot(x[atr_sample],p_signal[atr_sample,0],'go',label ='normal')\n",
        "plt.plot(x[ab_index],p_signal[ab_index,0],'ro',label='abnormal')\n",
        "\n",
        "plt.xlim(left,right)\n",
        "plt.ylim(p_signal[left:right].min()-0.05,p_signal[left:right,0].max()+0.05)\n",
        "plt.xlabel('time index')\n",
        "plt.ylabel('ECG signal')\n",
        "plt.legend(bbox_to_anchor = (1.04,1), loc = 'upper left')\n",
        "plt.show()"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "_o-RDDFmt3PP"
      },
      "source": [
        "# Make a dataset"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Z8gVqOVyt3PP"
      },
      "source": [
        "Let's make a dataset that is centered on beats with +- 3 seconds before and after."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 92,
      "metadata": {
        "id": "AhGdh1Kot3PP"
      },
      "outputs": [],
      "source": [
        "def make_dataset(pts, num_sec, fs, abnormal):\n",
        "    # function for making dataset ignoring non-beats\n",
        "    # input:\n",
        "    # pts - list of patients\n",
        "    # num_sec = number of seconds to include before and after the beat\n",
        "    # fs = frequency\n",
        "    # output:\n",
        "    #   X_all = signal (nbeats , num_sec * fs columns)\n",
        "    #   Y_all = binary is abnormal (nbeats, 1)\n",
        "    #   sym_all = beat annotation symbol (nbeats,1)\n",
        "\n",
        "    # initialize numpy arrays\n",
        "    num_cols = 2*num_sec * fs\n",
        "    X_all = np.zeros((1,num_cols))\n",
        "    Y_all = np.zeros((1,1))\n",
        "    sym_all = []\n",
        "\n",
        "    # list to keep track of number of beats across patients\n",
        "    max_rows = []\n",
        "\n",
        "    for pt in pts:\n",
        "        file = data_path + pt\n",
        "\n",
        "        p_signal, atr_sym, atr_sample = load_ecg(file)\n",
        "\n",
        "        # grab the first signal\n",
        "        p_signal = p_signal[:,0]\n",
        "\n",
        "        # make df to exclude the nonbeats\n",
        "        df_ann = pd.DataFrame({'atr_sym':atr_sym,\n",
        "                              'atr_sample':atr_sample})\n",
        "        df_ann = df_ann.loc[df_ann.atr_sym.isin(abnormal + ['N'])]\n",
        "\n",
        "        X,Y,sym = build_XY(p_signal,df_ann, num_cols, abnormal)\n",
        "        sym_all = sym_all+sym\n",
        "        max_rows.append(X.shape[0])\n",
        "        X_all = np.append(X_all,X,axis = 0)\n",
        "        Y_all = np.append(Y_all,Y,axis = 0)\n",
        "    # drop the first zero row\n",
        "    X_all = X_all[1:,:]\n",
        "    Y_all = Y_all[1:,:]\n",
        "\n",
        "    # check sizes make sense\n",
        "    assert np.sum(max_rows) == X_all.shape[0], 'number of X, max_rows rows messed up'\n",
        "    assert Y_all.shape[0] == X_all.shape[0], 'number of X, Y rows messed up'\n",
        "    assert Y_all.shape[0] == len(sym_all), 'number of Y, sym rows messed up'\n",
        "\n",
        "    return X_all, Y_all, sym_all\n",
        "\n",
        "\n",
        "\n",
        "def build_XY(p_signal, df_ann, num_cols, abnormal):\n",
        "    # this function builds the X,Y matrices for each beat\n",
        "    # it also returns the original symbols for Y\n",
        "\n",
        "    num_rows = len(df_ann)\n",
        "\n",
        "    X = np.zeros((num_rows, num_cols))\n",
        "    Y = np.zeros((num_rows,1))\n",
        "    sym = []\n",
        "\n",
        "    # keep track of rows\n",
        "    max_row = 0\n",
        "\n",
        "    for atr_sample, atr_sym in zip(df_ann.atr_sample.values,df_ann.atr_sym.values):\n",
        "\n",
        "        left = max([0,(atr_sample - num_sec*fs) ])\n",
        "        right = min([len(p_signal),(atr_sample + num_sec*fs) ])\n",
        "        x = p_signal[left: right]\n",
        "        if len(x) == num_cols:\n",
        "            X[max_row,:] = x\n",
        "            Y[max_row,:] = int(atr_sym in abnormal)\n",
        "            sym.append(atr_sym)\n",
        "            max_row += 1\n",
        "    X = X[:max_row,:]\n",
        "    Y = Y[:max_row,:]\n",
        "    return X,Y,sym\n",
        ""
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "3WLALGXrt3PQ"
      },
      "source": [
        "# Lesson 1: split on patients not on samples"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "eRQ71n6Wt3PQ"
      },
      "source": [
        "Let's start by processing all of our patients."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 93,
      "metadata": {
        "id": "Ma7QaBvjt3PQ"
      },
      "outputs": [],
      "source": [
        "num_sec = 3\n",
        "fs = 360"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 94,
      "metadata": {
        "id": "6rVLiTrft3PQ"
      },
      "outputs": [],
      "source": [
        "X_all, Y_all, sym_all = make_dataset(pts, num_sec, fs, abnormal)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "FTGugUM-t3PQ"
      },
      "source": [
        "Imagine we naively just decided to randomly split our data by samples into a train and validation set."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 95,
      "metadata": {
        "id": "sbGpEXS3t3PQ"
      },
      "outputs": [],
      "source": [
        "from sklearn.model_selection import train_test_split\n",
        "\n",
        "X_train, X_valid, y_train, y_valid = train_test_split(X_all, Y_all, test_size=0.33, random_state=42)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "IqmoXUcYt3PQ"
      },
      "source": [
        "Now we are ready to build our first dense NN. We will do this in Keras for simplicity."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 96,
      "metadata": {
        "id": "c2chdDMht3PV"
      },
      "outputs": [],
      "source": [
        "from keras.models import Sequential\n",
        "from keras.layers import Dense, Flatten, Dropout\n",
        "from keras.utils import to_categorical"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 97,
      "metadata": {
        "id": "Zqs6gIGht3PV",
        "outputId": "17d44748-1c8d-4504-ba92-a729b8737d02",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "/usr/local/lib/python3.11/dist-packages/keras/src/layers/core/dense.py:87: UserWarning: Do not pass an `input_shape`/`input_dim` argument to a layer. When using Sequential models, prefer using an `Input(shape)` object as the first layer in the model instead.\n",
            "  super().__init__(activity_regularizer=activity_regularizer, **kwargs)\n"
          ]
        }
      ],
      "source": [
        "# build the same model\n",
        "# lets test out relu (a different activation function) and add drop out (for regularization)\n",
        "model = Sequential()\n",
        "model.add(Dense(32, activation = 'relu', input_dim = X_train.shape[1]))\n",
        "model.add(Dropout(rate = 0.25))\n",
        "model.add(Dense(1, activation = 'sigmoid'))"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 98,
      "metadata": {
        "id": "97tfscLzt3PV"
      },
      "outputs": [],
      "source": [
        "# compile the model - use categorical crossentropy, and the adam optimizer\n",
        "model.compile(\n",
        "                loss = 'binary_crossentropy',\n",
        "                optimizer = 'adam',\n",
        "                metrics = ['accuracy'])"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 99,
      "metadata": {
        "id": "B1M9UaHqt3PV",
        "outputId": "d7f499db-ff5f-4387-a143-0be7a4b9852a",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Epoch 1/5\n",
            "\u001b[1m2285/2285\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m11s\u001b[0m 4ms/step - accuracy: 0.8641 - loss: 0.3306\n",
            "Epoch 2/5\n",
            "\u001b[1m2285/2285\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m12s\u001b[0m 5ms/step - accuracy: 0.9457 - loss: 0.1681\n",
            "Epoch 3/5\n",
            "\u001b[1m2285/2285\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m9s\u001b[0m 4ms/step - accuracy: 0.9522 - loss: 0.1472\n",
            "Epoch 4/5\n",
            "\u001b[1m2285/2285\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m11s\u001b[0m 4ms/step - accuracy: 0.9572 - loss: 0.1355\n",
            "Epoch 5/5\n",
            "\u001b[1m2285/2285\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m9s\u001b[0m 4ms/step - accuracy: 0.9613 - loss: 0.1264\n"
          ]
        },
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "<keras.src.callbacks.history.History at 0x7ea80e36b590>"
            ]
          },
          "metadata": {},
          "execution_count": 99
        }
      ],
      "source": [
        "model.fit(X_train, y_train, batch_size = 32, epochs= 5, verbose = 1)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 101,
      "metadata": {
        "id": "o-_oBDPpt3PW"
      },
      "outputs": [],
      "source": [
        "from sklearn.metrics import roc_auc_score, accuracy_score, precision_score, recall_score\n",
        "def calc_prevalence(y_actual):\n",
        "    return (sum(y_actual)/len(y_actual))\n",
        "def calc_specificity(y_actual, y_pred, thresh):\n",
        "    # calculates specificity\n",
        "    return sum((y_pred < thresh) & (y_actual == 0)) /sum(y_actual ==0)\n",
        "def print_report(y_actual, y_pred, thresh):\n",
        "\n",
        "    auc = roc_auc_score(y_actual, y_pred)\n",
        "    accuracy = accuracy_score(y_actual, (y_pred > thresh))\n",
        "    recall = recall_score(y_actual, (y_pred > thresh))\n",
        "    precision = precision_score(y_actual, (y_pred > thresh))\n",
        "    specificity = calc_specificity(y_actual, y_pred, thresh)\n",
        "    print('AUC:%.3f'%auc)\n",
        "    print('accuracy:%.3f'%accuracy)\n",
        "    print('recall:%.3f'%recall)\n",
        "    print('precision:%.3f'%precision)\n",
        "    print('specificity:%.3f'%specificity)\n",
        "    print('prevalence:%.3f'%calc_prevalence(y_actual))\n",
        "    print(' ')\n",
        "    return auc, accuracy, recall, precision, specificity"
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "y_train_preds_dense = model.predict(X_train, verbose=1)\n",
        "y_valid_preds_dense = model.predict(X_valid, verbose=1)\n"
      ],
      "metadata": {
        "id": "gfFo7n9c0xHE",
        "outputId": "7cd66c9e-4fc7-4807-faca-5991cbd54282",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "execution_count": 102,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "\u001b[1m2285/2285\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m3s\u001b[0m 1ms/step\n",
            "\u001b[1m1126/1126\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m3s\u001b[0m 2ms/step\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 56,
      "metadata": {
        "id": "BXo7RtpUt3PW",
        "outputId": "c4db6d9a-5d9f-4722-a495-10cce17f5f0d",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 53
        }
      },
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "'y_train_preds_dense = model.predict_proba(X_train,verbose = 1)\\ny_valid_preds_dense = model.predict_proba(X_valid,verbose = 1)'"
            ],
            "application/vnd.google.colaboratory.intrinsic+json": {
              "type": "string"
            }
          },
          "metadata": {},
          "execution_count": 56
        }
      ],
      "source": [
        "'''y_train_preds_dense = model.predict_proba(X_train,verbose = 1)\n",
        "y_valid_preds_dense = model.predict_proba(X_valid,verbose = 1)'''"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 103,
      "metadata": {
        "id": "gyNPTIknt3PW",
        "outputId": "d7a2d664-cba7-4d73-ffe2-7ee6b12ff6d3",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "0.3147641457808909"
            ]
          },
          "metadata": {},
          "execution_count": 103
        }
      ],
      "source": [
        "thresh = (sum(y_train)/len(y_train))[0]\n",
        "thresh"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 104,
      "metadata": {
        "id": "9sM7dNzCt3PW",
        "outputId": "0a718311-041f-48ca-9c38-2217edb6a91f",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Train\n",
            "AUC:0.992\n",
            "accuracy:0.968\n",
            "recall:0.960\n",
            "precision:0.940\n",
            "specificity:0.972\n",
            "prevalence:0.315\n",
            " \n",
            "Valid\n",
            "AUC:0.989\n",
            "accuracy:0.961\n",
            "recall:0.951\n",
            "precision:0.927\n",
            "specificity:0.966\n",
            "prevalence:0.314\n",
            " \n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "<ipython-input-101-1edd4adce3e6>:18: DeprecationWarning: Conversion of an array with ndim > 0 to a scalar is deprecated, and will error in future. Ensure you extract a single element from your array before performing this operation. (Deprecated NumPy 1.25.)\n",
            "  print('specificity:%.3f'%specificity)\n",
            "<ipython-input-101-1edd4adce3e6>:19: DeprecationWarning: Conversion of an array with ndim > 0 to a scalar is deprecated, and will error in future. Ensure you extract a single element from your array before performing this operation. (Deprecated NumPy 1.25.)\n",
            "  print('prevalence:%.3f'%calc_prevalence(y_actual))\n",
            "<ipython-input-101-1edd4adce3e6>:18: DeprecationWarning: Conversion of an array with ndim > 0 to a scalar is deprecated, and will error in future. Ensure you extract a single element from your array before performing this operation. (Deprecated NumPy 1.25.)\n",
            "  print('specificity:%.3f'%specificity)\n",
            "<ipython-input-101-1edd4adce3e6>:19: DeprecationWarning: Conversion of an array with ndim > 0 to a scalar is deprecated, and will error in future. Ensure you extract a single element from your array before performing this operation. (Deprecated NumPy 1.25.)\n",
            "  print('prevalence:%.3f'%calc_prevalence(y_actual))\n"
          ]
        }
      ],
      "source": [
        "print('Train');\n",
        "print_report(y_train, y_train_preds_dense, thresh)\n",
        "print('Valid');\n",
        "print_report(y_valid, y_valid_preds_dense, thresh);"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "mC4UaYmZt3PW"
      },
      "source": [
        "Amazing! Not that hard! But wait, will this work on new patients? Perhaps not if each patient has a unique heart signature. Technically the same patient can show up in both the training and validation sets. This means that we may have accidentally leaked information across the datasets."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "YPbYITPmt3PW"
      },
      "source": [
        "We can try this again by splitting on patients instead of samples."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 105,
      "metadata": {
        "id": "7uw_9RBat3PW",
        "outputId": "bd803882-b584-4eb7-e584-e312de2bb296",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "36 12\n"
          ]
        }
      ],
      "source": [
        "import random\n",
        "random.seed( 42 )\n",
        "pts_train = random.sample(pts, 36)\n",
        "pts_valid = [pt for pt in pts if pt not in pts_train]\n",
        "print(len(pts_train), len(pts_valid))"
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "import os\n",
        "\n",
        "file_path = \"/content/drive/MyDrive/Arrhythmia-CNN-master/data/mit-bih-arrhythmia-database-1.0.0/x_mitdb/x_222.hea\"\n",
        "print(\"File exists:\", os.path.exists(file_path))\n"
      ],
      "metadata": {
        "id": "sKupOviC5T8-",
        "outputId": "1f46207a-0f2a-4eee-ae49-db50b547ddbb",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "execution_count": 106,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "File exists: True\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "print(\"data_path:\", data_path)\n"
      ],
      "metadata": {
        "id": "dZ_bV4a55kjg",
        "outputId": "e3c81edf-0524-40c6-b1a6-4f5c8937e120",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "execution_count": 107,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "data_path: /content/drive/MyDrive/Arrhythmia-CNN-master/data/mit-bih-arrhythmia-database-1.0.0/\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "import os\n",
        "\n",
        "file_path = \"/content/drive/MyDrive/Arrhythmia-CNN-master/data/mit-bih-arrhythmia-database-1.0.0/x_mitdb222.hea\"\n",
        "print(\"File exists:\", os.path.exists(file_path))\n"
      ],
      "metadata": {
        "id": "z2ZdJbFc71t5",
        "outputId": "b60aa139-7b13-4511-f623-5ddf6be065b8",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "execution_count": 108,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "File exists: False\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "import os\n",
        "\n",
        "dir_path = \"/content/drive/MyDrive/Arrhythmia-CNN-master/data/mit-bih-arrhythmia-database-1.0.0/\"\n",
        "print(\"Files in directory:\", os.listdir(dir_path))\n"
      ],
      "metadata": {
        "id": "ZGMpiLO-8klo",
        "outputId": "955115f8-979f-4df4-b742-5034a09ae0cd",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "execution_count": 109,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Files in directory: ['101.atr', '105.atr', '102.hea', '105.dat', '104.hea', '100.dat', '103.dat', '106.atr', '101.dat', '100.xws', '106.dat', '100.hea', '106.xws', '107.dat', '107.hea', '104.xws', '102-0.atr', '103.atr', '107.atr', '102.atr', '104.atr', '105.xws', '106.hea', '101.hea', '103.hea', '100.atr', '105.hea', '101.xws', '102.dat', '103.xws', '102.xws', '104.dat', '113.hea', '113.dat', '117.dat', '115.dat', '117.atr', '109.xws', '113.xws', '118.atr', '112.hea', '112.dat', '116.atr', '108.xws', '117.at_', '117.hea', '114.atr', '114.xws', '116.hea', '113.atr', '111.hea', '109.atr', '115.atr', '116.xws', '108.hea', '108.atr', '107.xws', '109.dat', '115.hea', '114.hea', '111.dat', '108.dat', '111.xws', '115.xws', '109.hea', '117.xws', '111.atr', '116.dat', '112.atr', '114.dat', '108.at_', '112.xws', '124.atr', '201.dat', '203.atr', '118.dat', '202.xws', '200.atr', '119.xws', '123.dat', '122.xws', '200.xws', '122.hea', '123.xws', '119.dat', '121.dat', '119.hea', '124.dat', '124.xws', '202.hea', '202.atr', '123.hea', '121.xws', '121.hea', '203.at_', '201.xws', '202.dat', '123.atr', '200.dat', '200.hea', '118.hea', '118.xws', '121.atr', '203.at-', '201.hea', '119.at_', '124.hea', '201.atr', '122.atr', '122.dat', '119.atr', '205.hea', '213.atr', '205.atr', '208.xws', '210.hea', '209.dat', '214.atr', '209.atr', '213.dat', '214.dat', '203.xws', '212.dat', '214.hea', '213.hea', '212.hea', '213.xws', '215.atr', '205.dat', '203.dat', '214.at_', '210.atr', '212.xws', '215.dat', '215.hea', '209.at_', '209.xws', '208.atr', '205.xws', '207.xws', '209.hea', '210.dat', '210.xws', '208.dat', '203.hea', '207.dat', '214.xws', '208.hea', '207.hea', '215.at_', '212.atr', '207.atr', '219.hea', '231.xws', '221.hea', '222.atr', '222.dat', '231.hea', '230.hea', '233.atr', '217.hea', '215.xws', '223.atr', '228.atr', '222.xws', '221.dat', '219.dat', '228.hea', '231.atr', '223.hea', '220.xws', '232.xws', '230.xws', '219.xws', '232.atr', '217.dat', '217.xws', '222.at_', '230.atr', '220.dat', '228.xws', '230.dat', '221.atr', '217.atr', '220.hea', '220.atr', '223.xws', '232.dat', '223.dat', '219.atr', '222.hea', '221.xws', '228.dat', '232.hea', '231.dat', '233.xws', 'index.shtml.shtml', '234.xws', '234.hea', 'RECORDS', '234.dat', '233.dat', '234.atr', '233.hea', 'ANNOTATORS', 'SHA256SUMS.txt', 'x_mitdb']\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 110,
      "metadata": {
        "id": "rWlHehLpt3PW",
        "outputId": "c85357ff-81c9-4e3e-a999-ecd98e6a7cd5",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "(80614, 2160) (80614, 1) 80614\n",
            "(28485, 2160) (28485, 1) 28485\n"
          ]
        }
      ],
      "source": [
        "X_train, y_train, sym_train = make_dataset(pts_train, num_sec, fs, abnormal)\n",
        "X_valid, y_valid, sym_valid = make_dataset(pts_valid, num_sec, fs, abnormal)\n",
        "print(X_train.shape, y_train.shape, len(sym_train))\n",
        "print(X_valid.shape, y_valid.shape, len(sym_valid))"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 111,
      "metadata": {
        "id": "BsiFtffVt3PW",
        "outputId": "1b0cdeda-4086-40c1-d90e-50bf04f3690e",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "/usr/local/lib/python3.11/dist-packages/keras/src/layers/core/dense.py:87: UserWarning: Do not pass an `input_shape`/`input_dim` argument to a layer. When using Sequential models, prefer using an `Input(shape)` object as the first layer in the model instead.\n",
            "  super().__init__(activity_regularizer=activity_regularizer, **kwargs)\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Epoch 1/5\n",
            "\u001b[1m2520/2520\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m22s\u001b[0m 8ms/step - accuracy: 0.8879 - loss: 0.2930\n",
            "Epoch 2/5\n",
            "\u001b[1m2520/2520\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m12s\u001b[0m 4ms/step - accuracy: 0.9549 - loss: 0.1486\n",
            "Epoch 3/5\n",
            "\u001b[1m2520/2520\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m10s\u001b[0m 4ms/step - accuracy: 0.9625 - loss: 0.1271\n",
            "Epoch 4/5\n",
            "\u001b[1m2520/2520\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m9s\u001b[0m 3ms/step - accuracy: 0.9661 - loss: 0.1158\n",
            "Epoch 5/5\n",
            "\u001b[1m2520/2520\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m10s\u001b[0m 4ms/step - accuracy: 0.9696 - loss: 0.1070\n"
          ]
        },
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "<keras.src.callbacks.history.History at 0x7ea80e355e50>"
            ]
          },
          "metadata": {},
          "execution_count": 111
        }
      ],
      "source": [
        "# build the same model\n",
        "# lets test out relu (a different activation function) and add drop out (for regularization)\n",
        "model = Sequential()\n",
        "model.add(Dense(32, activation = 'relu', input_dim = X_train.shape[1]))\n",
        "model.add(Dropout(rate = 0.25))\n",
        "model.add(Dense(1, activation = 'sigmoid'))\n",
        "\n",
        "# compile the model - use categorical crossentropy, and the adam optimizer\n",
        "model.compile(\n",
        "                loss = 'binary_crossentropy',\n",
        "                optimizer = 'adam',\n",
        "                metrics = ['accuracy'])\n",
        "\n",
        "model.fit(X_train, y_train, batch_size = 32, epochs= 5, verbose = 1)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 113,
      "metadata": {
        "id": "6groIrDNt3PW",
        "outputId": "037ccf6a-333f-4b9c-bee9-625a1857b2bb",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "\u001b[1m2520/2520\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m8s\u001b[0m 3ms/step\n",
            "\u001b[1m891/891\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 1ms/step\n"
          ]
        }
      ],
      "source": [
        "y_train_preds_dense = model.predict(X_train,verbose = 1)\n",
        "y_valid_preds_dense = model.predict(X_valid,verbose = 1)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 114,
      "metadata": {
        "id": "Lmu4CNlnt3PX",
        "outputId": "2d4ae627-31d4-440a-bec7-9cc3ddd52647",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "0.29906715955045027"
            ]
          },
          "metadata": {},
          "execution_count": 114
        }
      ],
      "source": [
        "thresh = (sum(y_train)/len(y_train))[0]\n",
        "thresh"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 115,
      "metadata": {
        "id": "jkkbFDsXt3PX",
        "outputId": "e0e32c13-185f-4e5c-d73b-3df5d3cd9209",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Train\n",
            "AUC:0.994\n",
            "accuracy:0.978\n",
            "recall:0.956\n",
            "precision:0.971\n",
            "specificity:0.988\n",
            "prevalence:0.299\n",
            " \n",
            "Valid\n",
            "AUC:0.865\n",
            "accuracy:0.754\n",
            "recall:0.381\n",
            "precision:0.848\n",
            "specificity:0.962\n",
            "prevalence:0.358\n",
            " \n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "<ipython-input-101-1edd4adce3e6>:18: DeprecationWarning: Conversion of an array with ndim > 0 to a scalar is deprecated, and will error in future. Ensure you extract a single element from your array before performing this operation. (Deprecated NumPy 1.25.)\n",
            "  print('specificity:%.3f'%specificity)\n",
            "<ipython-input-101-1edd4adce3e6>:19: DeprecationWarning: Conversion of an array with ndim > 0 to a scalar is deprecated, and will error in future. Ensure you extract a single element from your array before performing this operation. (Deprecated NumPy 1.25.)\n",
            "  print('prevalence:%.3f'%calc_prevalence(y_actual))\n",
            "<ipython-input-101-1edd4adce3e6>:18: DeprecationWarning: Conversion of an array with ndim > 0 to a scalar is deprecated, and will error in future. Ensure you extract a single element from your array before performing this operation. (Deprecated NumPy 1.25.)\n",
            "  print('specificity:%.3f'%specificity)\n",
            "<ipython-input-101-1edd4adce3e6>:19: DeprecationWarning: Conversion of an array with ndim > 0 to a scalar is deprecated, and will error in future. Ensure you extract a single element from your array before performing this operation. (Deprecated NumPy 1.25.)\n",
            "  print('prevalence:%.3f'%calc_prevalence(y_actual))\n"
          ]
        }
      ],
      "source": [
        "print('Train');\n",
        "print_report(y_train, y_train_preds_dense, thresh)\n",
        "print('Valid');\n",
        "print_report(y_valid, y_valid_preds_dense, thresh);"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "z9QzwU-vt3PX"
      },
      "source": [
        "Validation score is much different now! Makes sense since we had data leakage before."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "KIEJueKpt3PX"
      },
      "source": [
        "# Lesson 2: learning curve can tells us we should get more data!"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "lPSck_3Rt3PX"
      },
      "source": [
        "Given the overfitting between training and validation. Let's make a simple learning curve to see if we should go collect more data."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 117,
      "metadata": {
        "id": "cNAZKUQkt3PX",
        "outputId": "8e8acdcc-5627-4c59-a36c-3f17a0b90940",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "1\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "/usr/local/lib/python3.11/dist-packages/keras/src/layers/core/dense.py:87: UserWarning: Do not pass an `input_shape`/`input_dim` argument to a layer. When using Sequential models, prefer using an `Input(shape)` object as the first layer in the model instead.\n",
            "  super().__init__(activity_regularizer=activity_regularizer, **kwargs)\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "- 0.9384158285250829 0.7119638053044903\n",
            "18\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "/usr/local/lib/python3.11/dist-packages/keras/src/layers/core/dense.py:87: UserWarning: Do not pass an `input_shape`/`input_dim` argument to a layer. When using Sequential models, prefer using an `Input(shape)` object as the first layer in the model instead.\n",
            "  super().__init__(activity_regularizer=activity_regularizer, **kwargs)\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "- 0.9950351944768276 0.8213138200926654\n",
            "36\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "/usr/local/lib/python3.11/dist-packages/keras/src/layers/core/dense.py:87: UserWarning: Do not pass an `input_shape`/`input_dim` argument to a layer. When using Sequential models, prefer using an `Input(shape)` object as the first layer in the model instead.\n",
            "  super().__init__(activity_regularizer=activity_regularizer, **kwargs)\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "- 0.9930491715080298 0.8841301697274927\n"
          ]
        }
      ],
      "source": [
        "aucs_train = []\n",
        "aucs_valid = []\n",
        "\n",
        "n_pts = [1,18,36]\n",
        "for n_pt in n_pts:\n",
        "\n",
        "    print(n_pt)\n",
        "    pts_sub = pts_train[:n_pt]\n",
        "    X_sub, y_sub, sym_sub = make_dataset(pts_sub, num_sec, fs,abnormal)\n",
        "\n",
        "    # build the same model\n",
        "    # lets test out relu (a different activation function) and add drop out (for regularization)\n",
        "    model = Sequential()\n",
        "    model.add(Dense(32, activation = 'relu', input_dim = X_train.shape[1]))\n",
        "    model.add(Dropout(rate = 0.25))\n",
        "    model.add(Dense(1, activation = 'sigmoid'))\n",
        "\n",
        "    # compile the model - use categorical crossentropy, and the adam optimizer\n",
        "    model.compile(\n",
        "                    loss = 'binary_crossentropy',\n",
        "                    optimizer = 'adam',\n",
        "                    metrics = ['accuracy'])\n",
        "\n",
        "    model.fit(X_sub, y_sub, batch_size = 32, epochs= 5, verbose = 0)\n",
        "    y_sub_preds_dense = model.predict(X_sub,verbose = 0)\n",
        "    y_valid_preds_dense = model.predict(X_valid,verbose = 0)\n",
        "\n",
        "    auc_train = roc_auc_score(y_sub, y_sub_preds_dense)\n",
        "    auc_valid = roc_auc_score(y_valid, y_valid_preds_dense)\n",
        "    print('-',auc_train, auc_valid)\n",
        "    aucs_train.append(auc_train)\n",
        "    aucs_valid.append(auc_valid)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 118,
      "metadata": {
        "id": "rtFkH7pAt3PX",
        "outputId": "07d140db-fcb6-42e1-df06-140fcee1d861",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 449
        }
      },
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 640x480 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        }
      ],
      "source": [
        "plt.plot(n_pts, aucs_train, 'o-',label = 'Train')\n",
        "plt.plot(n_pts, aucs_valid, 'o-',label = 'Valid')\n",
        "plt.xlabel('Number Training Pts')\n",
        "plt.ylabel('AUC')\n",
        "plt.legend(bbox_to_anchor = (1.04,1), loc = 'upper left')\n",
        "plt.show()"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "XcKuZppGt3PX"
      },
      "source": [
        "More data appears to add extra value to the model."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "3k5-szBut3PX"
      },
      "source": [
        "# Lesson 3: test multiple types of deep learning models"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "kbl-q572t3PX"
      },
      "source": [
        "## CNN"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "h3W_gwiRt3PX"
      },
      "source": [
        "Let's start by making a CNN. Here we will use a 1 dimensional CNN (as opposed to the 2D CNN for images)."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "NNGIyrX-t3PY"
      },
      "source": [
        "A CNN is a special type of deep learning algorithm which uses a set of filters and the convolution operator to reduce the number of parameters. This algorithm sparked the state-of-the-art techniques for image classification. Essentially, the way this works for 1D CNN is to take a filter (kernel) of size `kernel_size` starting with the first time stamp. The convolution operator takes the filter and multiplies each element against the first `kernel_size` time steps. These products are then summed for the first cell in the next layer of the neural network. The filter then moves over by `stride` time steps and repeats. The default `stride` in Keras is 1, which we will use. In image classification, most people use `padding` which allows you pick up some features on the edges of the image by adding 'extra' cells, we will use the default padding which is 0. The output of the convolution is then multiplied by a set of weights W and added to a bias b and then passed through a non-linear activation function as in dense neural network. You can then repeat this with addition CNN layers if desired. Here we will use Dropout which is a technique for reducing overfitting by randomly removing some nodes."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 119,
      "metadata": {
        "id": "kUtuDhNYt3PY",
        "outputId": "f6d0f8b2-3f22-489e-ba8d-78c287abb5f1",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "(80614, 2160, 1)\n",
            "(28485, 2160, 1)\n"
          ]
        }
      ],
      "source": [
        "# reshape input to be [samples, time steps, features = 1]\n",
        "X_train_cnn = np.reshape(X_train, (X_train.shape[0], X_train.shape[1], 1))\n",
        "X_valid_cnn = np.reshape(X_valid, (X_valid.shape[0], X_valid.shape[1], 1))\n",
        "\n",
        "print(X_train_cnn.shape)\n",
        "print(X_valid_cnn.shape)\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 120,
      "metadata": {
        "id": "zt-SQpZNt3PY"
      },
      "outputs": [],
      "source": [
        "from keras.layers import Conv1D"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 121,
      "metadata": {
        "id": "_lD2MScht3PY",
        "outputId": "d7f4fd55-083a-479b-b00a-8749b83c0f02",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "/usr/local/lib/python3.11/dist-packages/keras/src/layers/convolutional/base_conv.py:107: UserWarning: Do not pass an `input_shape`/`input_dim` argument to a layer. When using Sequential models, prefer using an `Input(shape)` object as the first layer in the model instead.\n",
            "  super().__init__(activity_regularizer=activity_regularizer, **kwargs)\n"
          ]
        }
      ],
      "source": [
        "model = Sequential()\n",
        "model.add(Conv1D(filters = 128, kernel_size = 5, activation = 'relu', input_shape = (2160,1)))\n",
        "model.add(Dropout(rate = 0.25))\n",
        "model.add(Flatten())\n",
        "model.add(Dense(1, activation = 'sigmoid'))\n",
        "\n",
        "# compile the model - use categorical crossentropy, and the adam optimizer\n",
        "model.compile(\n",
        "                loss = 'binary_crossentropy',\n",
        "                optimizer = 'adam',\n",
        "                metrics = ['accuracy'])"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 122,
      "metadata": {
        "id": "OwVB7FLGt3PY",
        "outputId": "a5224543-6bf0-47ac-98fd-1b8f270010b1",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Epoch 1/2\n",
            "\u001b[1m2520/2520\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m555s\u001b[0m 219ms/step - accuracy: 0.9029 - loss: 0.2663\n",
            "Epoch 2/2\n",
            "\u001b[1m2520/2520\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m538s\u001b[0m 213ms/step - accuracy: 0.9620 - loss: 0.1274\n"
          ]
        },
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "<keras.src.callbacks.history.History at 0x7ea95b051710>"
            ]
          },
          "metadata": {},
          "execution_count": 122
        }
      ],
      "source": [
        "model.fit(X_train_cnn, y_train, batch_size = 32, epochs= 2, verbose = 1)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 123,
      "metadata": {
        "id": "juWFfbMnt3PY",
        "outputId": "792057b2-555e-4d00-a740-313b819048ab",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "\u001b[1m2520/2520\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m78s\u001b[0m 31ms/step\n",
            "\u001b[1m891/891\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m27s\u001b[0m 31ms/step\n"
          ]
        }
      ],
      "source": [
        "y_train_preds_cnn = model.predict(X_train_cnn,verbose = 1)\n",
        "y_valid_preds_cnn = model.predict(X_valid_cnn,verbose = 1)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 124,
      "metadata": {
        "id": "Xv0TB6z4t3PY",
        "outputId": "eaec5800-2b57-4125-da6d-c6c3d42a50d8",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Train\n",
            "AUC:0.990\n",
            "accuracy:0.972\n",
            "recall:0.948\n",
            "precision:0.958\n",
            "specificity:0.982\n",
            "prevalence:0.299\n",
            " \n",
            "Valid\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "<ipython-input-101-1edd4adce3e6>:18: DeprecationWarning: Conversion of an array with ndim > 0 to a scalar is deprecated, and will error in future. Ensure you extract a single element from your array before performing this operation. (Deprecated NumPy 1.25.)\n",
            "  print('specificity:%.3f'%specificity)\n",
            "<ipython-input-101-1edd4adce3e6>:19: DeprecationWarning: Conversion of an array with ndim > 0 to a scalar is deprecated, and will error in future. Ensure you extract a single element from your array before performing this operation. (Deprecated NumPy 1.25.)\n",
            "  print('prevalence:%.3f'%calc_prevalence(y_actual))\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "AUC:0.894\n",
            "accuracy:0.823\n",
            "recall:0.689\n",
            "precision:0.788\n",
            "specificity:0.897\n",
            "prevalence:0.358\n",
            " \n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "<ipython-input-101-1edd4adce3e6>:18: DeprecationWarning: Conversion of an array with ndim > 0 to a scalar is deprecated, and will error in future. Ensure you extract a single element from your array before performing this operation. (Deprecated NumPy 1.25.)\n",
            "  print('specificity:%.3f'%specificity)\n",
            "<ipython-input-101-1edd4adce3e6>:19: DeprecationWarning: Conversion of an array with ndim > 0 to a scalar is deprecated, and will error in future. Ensure you extract a single element from your array before performing this operation. (Deprecated NumPy 1.25.)\n",
            "  print('prevalence:%.3f'%calc_prevalence(y_actual))\n"
          ]
        }
      ],
      "source": [
        "print('Train');\n",
        "print_report(y_train, y_train_preds_cnn, thresh)\n",
        "print('Valid');\n",
        "print_report(y_valid, y_valid_preds_cnn, thresh);"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "JQ7CImUTt3PY"
      },
      "source": [
        "## LSTM"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "YrBMddZIt3PY"
      },
      "outputs": [],
      "source": []
    },
    {
      "cell_type": "code",
      "execution_count": 125,
      "metadata": {
        "id": "V6WXu3mJt3PY"
      },
      "outputs": [],
      "source": [
        "from keras.layers import Bidirectional, LSTM"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 126,
      "metadata": {
        "id": "zJg948O8t3PY",
        "outputId": "915e3c49-e25b-4296-bed9-d6058839a645",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "/usr/local/lib/python3.11/dist-packages/keras/src/layers/rnn/rnn.py:200: UserWarning: Do not pass an `input_shape`/`input_dim` argument to a layer. When using Sequential models, prefer using an `Input(shape)` object as the first layer in the model instead.\n",
            "  super().__init__(**kwargs)\n"
          ]
        }
      ],
      "source": [
        "model = Sequential()\n",
        "model.add(Bidirectional(LSTM(64, input_shape=(X_train_cnn.shape[1], X_train_cnn.shape[2]))))\n",
        "model.add(Dropout(rate = 0.25))\n",
        "model.add(Dense(1, activation = 'sigmoid'))\n",
        "model.compile(\n",
        "                loss = 'binary_crossentropy',\n",
        "                optimizer = 'adam',\n",
        "                metrics = ['accuracy'])"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "lgiQF4_Mt3PY"
      },
      "source": [
        "Reduce dataset to make this feasible for weekend project"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 127,
      "metadata": {
        "id": "zKrV19fpt3PY",
        "outputId": "89f311e7-ca1c-4c1e-ca06-3c8912896582",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "\u001b[1m313/313\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m474s\u001b[0m 1s/step - accuracy: 0.6813 - loss: 0.5908\n"
          ]
        },
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "<keras.src.callbacks.history.History at 0x7ea95aeea5d0>"
            ]
          },
          "metadata": {},
          "execution_count": 127
        }
      ],
      "source": [
        "model.fit(X_train_cnn[:10000], y_train[:10000], batch_size = 32, epochs= 1, verbose = 1)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 129,
      "metadata": {
        "id": "0a55WXGvt3PZ",
        "outputId": "6e29e313-97ce-42f8-a41d-6c67ae9169f4",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "\u001b[1m313/313\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m133s\u001b[0m 420ms/step\n",
            "\u001b[1m891/891\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m339s\u001b[0m 381ms/step\n"
          ]
        }
      ],
      "source": [
        "y_train_preds_lstm = model.predict(X_train_cnn[:10000],verbose = 1)\n",
        "y_valid_preds_lstm = model.predict(X_valid_cnn,verbose = 1)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 130,
      "metadata": {
        "id": "4udKDizSt3PZ",
        "outputId": "751fcfde-5bb6-4431-927c-ed235b3ab74e",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Train\n",
            "AUC:0.784\n",
            "accuracy:0.757\n",
            "recall:0.787\n",
            "precision:0.735\n",
            "specificity:0.728\n",
            "prevalence:0.489\n",
            " \n",
            "Valid\n",
            "AUC:0.506\n",
            "accuracy:0.561\n",
            "recall:0.285\n",
            "precision:0.358\n",
            "specificity:0.715\n",
            "prevalence:0.358\n",
            " \n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "<ipython-input-101-1edd4adce3e6>:18: DeprecationWarning: Conversion of an array with ndim > 0 to a scalar is deprecated, and will error in future. Ensure you extract a single element from your array before performing this operation. (Deprecated NumPy 1.25.)\n",
            "  print('specificity:%.3f'%specificity)\n",
            "<ipython-input-101-1edd4adce3e6>:19: DeprecationWarning: Conversion of an array with ndim > 0 to a scalar is deprecated, and will error in future. Ensure you extract a single element from your array before performing this operation. (Deprecated NumPy 1.25.)\n",
            "  print('prevalence:%.3f'%calc_prevalence(y_actual))\n",
            "<ipython-input-101-1edd4adce3e6>:18: DeprecationWarning: Conversion of an array with ndim > 0 to a scalar is deprecated, and will error in future. Ensure you extract a single element from your array before performing this operation. (Deprecated NumPy 1.25.)\n",
            "  print('specificity:%.3f'%specificity)\n",
            "<ipython-input-101-1edd4adce3e6>:19: DeprecationWarning: Conversion of an array with ndim > 0 to a scalar is deprecated, and will error in future. Ensure you extract a single element from your array before performing this operation. (Deprecated NumPy 1.25.)\n",
            "  print('prevalence:%.3f'%calc_prevalence(y_actual))\n"
          ]
        }
      ],
      "source": [
        "print('Train');\n",
        "print_report(y_train[:10000], y_train_preds_lstm, thresh)\n",
        "print('Valid');\n",
        "print_report(y_valid, y_valid_preds_lstm, thresh);"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 131,
      "metadata": {
        "id": "0x4s8j-zt3PZ",
        "outputId": "4c8d7ca0-44dc-4433-9fec-388cf8645c2a",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 472
        }
      },
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 640x480 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        }
      ],
      "source": [
        "from sklearn.metrics import roc_curve, roc_auc_score\n",
        "\n",
        "\n",
        "fpr_valid_cnn, tpr_valid_cnn, t_valid_cnn = roc_curve(y_valid, y_valid_preds_cnn)\n",
        "auc_valid_cnn = roc_auc_score(y_valid, y_valid_preds_cnn)\n",
        "\n",
        "fpr_valid_dense, tpr_valid_dense, t_valid_dense = roc_curve(y_valid, y_valid_preds_dense)\n",
        "auc_valid_dense = roc_auc_score(y_valid, y_valid_preds_dense)\n",
        "\n",
        "fpr_valid_lstm, tpr_valid_lstm, t_valid_lstm = roc_curve(y_valid, y_valid_preds_lstm)\n",
        "auc_valid_lstm = roc_auc_score(y_valid, y_valid_preds_lstm)\n",
        "\n",
        "plt.plot(fpr_valid_cnn, tpr_valid_cnn, 'g-', label = 'CNN AUC:%.3f'%auc_valid_cnn)\n",
        "plt.plot(fpr_valid_dense, tpr_valid_dense, 'r-', label = 'Dense AUC:%.3f'%auc_valid_dense)\n",
        "plt.plot(fpr_valid_lstm, tpr_valid_lstm, 'b-', label = 'LSTM AUC:%.3f'%auc_valid_lstm)\n",
        "\n",
        "plt.plot([0,1],[0,1], 'k--')\n",
        "plt.xlabel('FPR')\n",
        "plt.ylabel('TPR')\n",
        "plt.legend(bbox_to_anchor = (1.04,1), loc = 'upper left')\n",
        "plt.title('Validation Set')\n",
        "plt.show()"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "g1CIdq_Ft3PZ"
      },
      "outputs": [],
      "source": []
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "3gADtJurt3PZ"
      },
      "outputs": [],
      "source": []
    }
  ],
  "metadata": {
    "kernelspec": {
      "display_name": "tutorials",
      "language": "python",
      "name": "tutorials"
    },
    "language_info": {
      "codemirror_mode": {
        "name": "ipython",
        "version": 3
      },
      "file_extension": ".py",
      "mimetype": "text/x-python",
      "name": "python",
      "nbconvert_exporter": "python",
      "pygments_lexer": "ipython3",
      "version": "3.6.9"
    },
    "colab": {
      "provenance": [],
      "include_colab_link": true
    }
  },
  "nbformat": 4,
  "nbformat_minor": 0
}